package demo.kk.demo1;


import java.util.ArrayList;
import java.util.Arrays;
import java.util.LinkedList;
import java.util.List;
import java.util.PriorityQueue;
import java.util.Queue;
import java.util.Scanner;

/**
 * @author : feixiang.li
 * @since : 2025-09-22 15:01
 */
public class Main {

    // 1 3 2 2 3 3
    //3 2
    public static void main(String[] args) {

        Scanner sc = new Scanner(System.in);
        /**
         * 4
         * 3
         * 2 1 1
         * 2 3 1
         * 3 4 1
         * 2
         */
        // 一个多少个节点
        int n = sc.nextInt();
        // 一共多少条边
        int m = sc.nextInt();
        List<List<int[]>> graph = new ArrayList<>();
        for (int i = 0; i < n; i++) {
            graph.add(new ArrayList<>());
        }
        // 读取数据
        for (int i = 0; i < m; i++) {
            int a = sc.nextInt();
            int b = sc.nextInt();
            int c = sc.nextInt();
            // 表示边 对应的 权重
            graph.get(a - 1).add(new int[]{b - 1, c});
        }

        // 病毒的位置节点
        int virus = sc.nextInt() - 1;
        int res = dijkstra(graph, virus);
        System.out.println(res);
    }

    public static int dijkstra(List<List<int[]>> graph, int start) {

        // 初始化距离数组，初始值为无穷大-一开始为开始节点 到其他所有节点都是无穷大
        int[] dist = new int[graph.size()];
        Arrays.fill(dist, Integer.MAX_VALUE);
        dist[start] = 0;
        // 设置优先级队列
        PriorityQueue<int[]> queue = new PriorityQueue<>((o1, o2) -> o1[0] - o2[0]);
        queue.offer(new int[]{0, start});
        while (!queue.isEmpty()) {
            int[] cur = queue.poll();
            int curNode = cur[1];
            int curDist = cur[0];
            // 跳过已经处理过的节点
            if (curDist > dist[curNode]) {
                continue;
            }
            for (int[] next : graph.get(curNode)) {
                int nextNode = next[0];
                int nextDist = next[1];
                // 更新距离数组。如果当前节点到下一个节点的距离更短，则更新距离数组。
                if (dist[nextNode] > dist[curNode] + nextDist) {
                    dist[nextNode] = dist[curNode] + nextDist;
                    // 加入队列中
                    queue.offer(new int[]{dist[nextNode], nextNode});
                }
            }
        }
        int res = 0;
        for (int i = 0; i < dist.length; i++) {
            if (dist[i] == Integer.MAX_VALUE) {
                return -1;
            }
            res = Math.max(res, dist[i]);
        }
        return res;
    }

}
